/**
 * 文件重命名页面
 * 提供批量文件重命名功能
 */
import React, { useState, useCallback, useRef } from 'react';
import type { FileDropZoneRef } from '../../components/common/FileDropZone';
import { Card, Row, Col, Button, Input, message, Space, List, Tag, Switch, Progress } from 'antd';
import { FolderOutlined, EditOutlined, ClearOutlined, EyeOutlined } from '@ant-design/icons';
import toolsService, { RenameOptions } from '../../services/toolsService';
import FileDropZone from '../../components/common/FileDropZone';

/**
 * 文件重命名页面组件
 */
const FileRenamePage: React.FC = () => {
  const [renameFolderPath, setRenameFolderPath] = useState('');
  const [renamePreview, setRenamePreview] = useState<{originalName: string, newName: string}[]>([]);
  const [renameOptions, setRenameOptions] = useState<RenameOptions>({
    removeChinese: true,
    replaceSpaces: true,
    replaceWith: '' // 默认空格替换字符为空
  });
  const [includeSubfolders, setIncludeSubfolders] = useState(true); // 是否包含子文件夹
  const [processing, setProcessing] = useState(false);
  const [progress, setProgress] = useState(0);
  const [currentFile, setCurrentFile] = useState('');
  const [isDragDropMode, setIsDragDropMode] = useState(false); // 标识是否为拖放模式
  const droppedFilesRef = useRef<File[]>([]); // 保存拖放的文件引用
  const fileDropZoneRef = useRef<FileDropZoneRef>(null); // 引用FileDropZone组件

  // 清除预览状态
  const clearPreview = useCallback(() => {
    setRenamePreview([]);
    setRenameFolderPath('');
    setIsDragDropMode(false); // 退出拖放模式
    setProcessing(false);
    setProgress(0);
    setCurrentFile('');
    // 清除文件引用
    droppedFilesRef.current = [];
    // 重置FileDropZone组件的状态，清除lastEmitSignatureRef
    if (fileDropZoneRef.current) {
      fileDropZoneRef.current.reset();
    }
  }, []);

  // 监听重命名进度
  React.useEffect(() => {
    const handleProgress = (event: any, data: { progress: number; currentFile: string }) => {
      setProgress(data.progress);
      setCurrentFile(data.currentFile);
    };

    if ((window as any).electron?.ipc) {
      (window as any).electron.ipc.receive('batch-rename-progress', handleProgress);
    }

    return () => {
      if ((window as any).electron?.ipc) {
        // 清理监听器
        (window as any).electron.ipc.removeListener('batch-rename-progress', handleProgress);
      }
    };
  }, []);

  /**
   * 处理拖放的文件 - 简化版本，专注于文件处理
   */
  const processDroppedFiles = useCallback(async (files: File[]) => {
    try {
      // 直接使用工具服务处理文件，路径信息已在FileDropZone组件中处理
      const results = await toolsService.batchRenameFiles(files, renameOptions);
      setRenamePreview(results);
    } catch (error) {
      console.error('处理文件失败:', error);
      message.error('处理文件失败，请重试！');
    }
  }, [renameOptions]);

  /**
   * 处理文件拖放或选择事件
   */
  const handleFilesDropped = useCallback(async (files: File[], filePaths?: string[]) => {
    try {
      // 保存文件引用
      droppedFilesRef.current = files;
      
      // 设置为拖放模式
      setIsDragDropMode(true);

      if (filePaths && filePaths.length > 0) {
        // 检查是否有至少一个文件有完整路径
        const hasAnyPath = filePaths.some(filePath => 
          filePath && (filePath.indexOf('\\') >= 0 || filePath.indexOf('/') >= 0)
        );
        
        if (hasAnyPath) {
          // 使用第一个有完整路径的文件来确定目录
          const firstValidPath = filePaths.find(filePath => 
            filePath && (filePath.indexOf('\\') >= 0 || filePath.indexOf('/') >= 0)
          );
          
          if (firstValidPath) {
            // 提取目录路径（兼容 / 和 \\）
            const lastSlash = firstValidPath.lastIndexOf('/');
            const lastBackslash = firstValidPath.lastIndexOf('\\');
            const lastSeparator = Math.max(lastSlash, lastBackslash);
            
            if (lastSeparator > 0) {
              const dirPath = firstValidPath.substring(0, lastSeparator);
              setRenameFolderPath(dirPath);
              message.success(`检测到 ${files.length} 个文件，路径: ${dirPath}`);
              console.log('文件路径检测成功:', { firstValidPath, dirPath, fileCount: files.length });
            }
          }
        } else {
          // 没有文件有完整路径，清空路径并设置为拖放模式
          console.log('无法获取文件路径（file.path 未定义），将以文件名为依据处理。');
          message.info('检测到文件，但无法读取完整路径，重命名将基于文件名进行预览。');
          setRenameFolderPath(''); // 清空路径
        }
      } else {
        // 没有路径信息
        setRenameFolderPath('');
        message.info('检测到文件，但无法读取文件路径信息');
      }
      
      // 处理文件并在完成后显示一次成功提示
      await processDroppedFiles(files);
      message.success(`成功加载 ${files.length} 个文件！`);
    } catch (error) {
      console.error('处理文件时出错:', error);
      message.warning('处理文件失败，将使用文件名模式处理');
      setRenameFolderPath('');
      setIsDragDropMode(false); // 出错时退出拖放模式
    }
  }, [processDroppedFiles]);

  /**
   * 预览文件重命名
   */
  const previewRename = useCallback(async () => {
    // 如果已经有重命名预览结果，直接提示并返回
    if (renamePreview.length > 0) {
      message.success('预览已加载，可以直接执行重命名！');
      return;
    }

    if (!renameFolderPath.trim() && droppedFilesRef.current.length === 0) {
      message.warning('请拖放文件到上方区域或输入文件夹路径！');
      return;
    }

    try {
      if (renameFolderPath.trim() && !isDragDropMode) {
        // 扫描文件夹获取文件列表（仅在非拖放模式下）
        const scanResponse = await (window as any).electron.ipc.invoke('scan-folder-files', {
          folderPath: renameFolderPath.trim(),
          includeSubfolders: includeSubfolders,
          extensions: [] // 不过滤扩展名，处理所有文件
        });

        if (scanResponse && scanResponse.success) {
          const { files } = scanResponse.data;
          
          if (files.length === 0) {
            message.warning('文件夹中没有找到文件！');
            return;
          }

          // 创建模拟文件对象用于预览
          const mockFiles = files.map((filePath: string) => {
            const fileName = filePath.split('\\').pop() || filePath.split('/').pop() || 'unknown';
            const file = new File([''], fileName);
            // 存储完整路径信息，供后续使用
            (file as any).path = filePath;
            return file;
          });

          const results = await toolsService.batchRenameFiles(mockFiles, renameOptions);
          setRenamePreview(results);
          message.success(`成功加载 ${files.length} 个文件！`);
        } else {
          message.error(scanResponse?.error || '扫描文件夹失败！');
        }
      } else if (droppedFilesRef.current.length > 0) {
        // 使用拖放的文件
        const results = await toolsService.batchRenameFiles(droppedFilesRef.current, renameOptions);
        // 保存文件路径信息到预览结果中
        const resultsWithPaths = await Promise.all(results.map(async (result, index) => {
          const file = droppedFilesRef.current[index];
          
          // 获取文件路径信息（如果有）
          let filePath: string | undefined = (file as any).path;
          
          // 如果path属性不存在，尝试使用webUtils.getPathForFile方法获取路径
          if (!filePath && (window as any).electron?.getPathForFile) {
            try {
              filePath = (window as any).electron.getPathForFile(file);
            } catch (pathError) {
              console.warn('通过webUtils.getPathForFile获取路径失败:', pathError);
            }
          }
          
          return {
            ...result,
            // 保存原始文件路径（如果有）
            oldPath: filePath || result.originalName
          };
        }));
        setRenamePreview(resultsWithPaths);
        message.success(`成功加载 ${droppedFilesRef.current.length} 个文件！`);
      }
    } catch (error) {
      console.error('预览重命名失败:', error);
      message.error('预览重命名失败，请重试！');
    }
  }, [renameFolderPath, renameOptions, renamePreview.length, includeSubfolders, isDragDropMode]);

  /**
   * 执行文件重命名
   */
  const executeRename = useCallback(async () => {
    if (!renamePreview || renamePreview.length === 0) {
      message.warning('请先预览文件重命名结果！');
      return;
    }

    setProcessing(true);
    setProgress(0);

    try {
      // 检查是否有有效的文件夹路径（可能来自拖放文件自动检测）
      const hasValidFolderPath = renameFolderPath.trim() && renameFolderPath !== 'unknown';
      
      // 拖放模式下，始终只处理拖放的文件，不扫描整个文件夹
      if (hasValidFolderPath && !isDragDropMode) {
        // 模式1：使用文件夹路径（传统模式）
        // 扫描文件夹获取文件列表
        const scanResponse = await (window as any).electron.ipc.invoke('scan-folder-files', {
          folderPath: renameFolderPath.trim(),
          includeSubfolders: includeSubfolders,
          extensions: [] // 不过滤扩展名，处理所有文件
        });

        if (!scanResponse || !scanResponse.success) {
          message.error('扫描文件夹失败，无法执行重命名！');
          return;
        }

        const { files } = scanResponse.data;
        
        // 创建文件重命名映射
        const renameMap = files.map((filePath: string, index: number) => {
          const fileName = filePath.split('\\').pop() || filePath.split('/').pop() || 'unknown';
          const newName = renamePreview[index]?.newName || fileName;
          return {
            oldPath: filePath,
            newName: newName
          };
        });

        // 执行批量重命名（保存到原目录）
        const renameResponse = await (window as any).electron.ipc.invoke('batch-rename-files-with-content', {
          renameMappings: renameMap,
          saveToOriginal: true, // 保存到原目录
          originalDirectory: renameFolderPath.trim(),
          isDragDropFiles: false
        });

        if (renameResponse && renameResponse.success) {
          message.success(`成功重命名 ${renameMap.length} 个文件！`);
        } else {
          message.error(renameResponse?.error || '执行文件重命名失败！');
        }
      } else {
        // 模式2：拖放文件模式
        // 为每个预览项获取对应的完整路径信息
        const enhancedRenameMappings = await Promise.all(renamePreview.map(async (preview, index) => {
          const file = droppedFilesRef.current[index];
          const enhancedPreview: any = { ...preview };
          
          // 获取文件路径信息（如果有）
          let filePath: string | undefined = (file as any).path;
          
          // 如果path属性不存在，尝试使用webUtils.getPathForFile方法获取路径
          if (!filePath && (window as any).electron?.getPathForFile) {
            try {
              filePath = (window as any).electron.getPathForFile(file);
            } catch (pathError) {
              console.warn('通过webUtils.getPathForFile获取路径失败:', pathError);
            }
          }
          
          // 判断是否有完整路径
          const hasFullPath = filePath && (filePath.indexOf('\\') >= 0 || filePath.indexOf('/') >= 0);
          
          // 如果有完整路径就使用它，否则使用原始文件名
          enhancedPreview.oldPath = hasFullPath ? filePath : preview.originalName;
          enhancedPreview.hasFullPath = hasFullPath;
          
          return enhancedPreview;
        }));
        
        // 检查是否所有文件都有完整路径
        const hasAllPaths = enhancedRenameMappings.every((mapping: any) => mapping.hasFullPath);
        
        // 如果不是所有文件都有完整路径，则提示用户
        if (!hasAllPaths) {
          const missingPathsCount = enhancedRenameMappings.filter((m: any) => !m.hasFullPath).length;
          message.warning(`${missingPathsCount} 个文件缺少完整路径信息，将仅重命名有完整路径的文件`);
        }
        
        // 使用批量重命名功能，但告知这是拖放文件
        // 拖放文件模式下，直接使用enhancedRenameMappings中的oldPath属性（包含完整路径）
        const response = await (window as any).electron.ipc.invoke('batch-rename-files-with-content', {
          renameMappings: enhancedRenameMappings.filter((mapping: any) => mapping.hasFullPath), // 只处理有完整路径的文件
          saveToOriginal: true, // 始终保存到原目录
          isDragDropFiles: true // 标记这是拖放文件
        });

        if (response && response.success) {
          const { successCount, totalCount, errors, mode } = response.data || response;
          
          if (successCount === totalCount) {
            message.success(`成功重命名 ${successCount} 个文件！原文件已被替换`);
          } else {
            message.warning(`重命名完成：成功 ${successCount}/${totalCount} 个文件`);
            if (errors && errors.length > 0) {
              console.warn('重命名错误:', errors);
              message.error(`部分文件重命名失败：${errors.join(', ')}`);
            }
          }
        } else {
          message.error(response?.error || '文件重命名失败！');
        }
      }
      
      // 清空预览和路径（成功或部分成功时都清空）
      setRenamePreview([]);
      setRenameFolderPath('');
      setIsDragDropMode(false); // 退出拖放模式
      droppedFilesRef.current = [];
      
    } catch (error) {
      console.error('文件重命名失败:', error);
      message.error('文件重命名失败，请重试！');
    } finally {
      setProcessing(false);
      setProgress(0);
    }
  }, [renamePreview, renameFolderPath, includeSubfolders, isDragDropMode]);

  return (
    <div className="app-page">
      <Row gutter={[24, 24]}>
        <Col span={24}>
          <Card
            title={
              <Space>
                <EditOutlined style={{ color: 'var(--app-primary-color)' }} />
                批量文件重命名
              </Space>
            }
            extra={<Tag color="green">文件管理</Tag>}
          >
            <Space direction="vertical" style={{ width: '100%' }} size="large">
              {/* 文件拖放区域 - 使用通用组件 */}
              <FileDropZone
                ref={fileDropZoneRef}
                onFilesDropped={handleFilesDropped}
                title="点击或拖拽文件到此处"
                description="支持批量选择多个文件进行重命名"
              />

              {/* 仅在非拖放模式下显示文件夹路径输入框 */}
              {!isDragDropMode && (
                <div>
                  <div style={{ marginBottom: '8px' }}>
                    <strong>文件夹路径（可选）：</strong>
                  </div>
                  <div style={{ display: 'flex', gap: '8px' }}>
                    <Input
                      placeholder="请输入要处理的文件夹路径（或使用上方拖放功能）"
                      value={renameFolderPath}
                      onChange={(e) => setRenameFolderPath(e.target.value)}
                      prefix={<FolderOutlined />}
                      size="large"
                      style={{ flex: 1 }}
                    />
                    <Button 
                      icon={<FolderOutlined />} 
                      onClick={async () => {
                        try {
                          const result = await (window as any).electron?.ipc?.invoke('select-folder');
                          if (result && result.success) {
                            setRenameFolderPath(result.path);
                          } else if (result && result.canceled) {
                            // 用户取消选择，不执行任何操作
                          } else {
                            message.error('选择文件夹失败');
                          }
                        } catch (error) {
                          console.error('选择文件夹时出错:', error);
                          message.error('选择文件夹时出错');
                        }
                      }}
                      size="large"
                    >
                      选择
                    </Button>
                  </div>
                </div>
              )}

              {renamePreview.length > 0 && (
                <div>
                  <div style={{ marginBottom: '16px' }}>
                    <strong>重命名预览：</strong>
                  </div>
                  <List
                    size="small"
                    bordered
                    dataSource={renamePreview}
                    renderItem={(item: any) => {
                      const originalName = item.originalName || item["originalName"] || '';
                      const newName = item.newName || item["newName"] || '';
                      const oldPath = item.oldPath as string | undefined;
                      // 判断 oldPath 是否为完整路径（包含分隔符）
                      const hasFullPath = !!oldPath && (oldPath.indexOf('\\') >= 0 || oldPath.indexOf('/') >= 0);

                      return (
                        <List.Item>
                          <Space direction="vertical" style={{ width: '100%' }}>
                            <div>
                              <Tag color="default" style={{ textDecoration: 'line-through', opacity: 0.6 }}>
                                原文件名: {originalName}
                              </Tag>
                              <Tag color="success" style={{ marginLeft: 8 }}>
                                新文件名: {newName}
                              </Tag>
                            </div>
                            {oldPath && (
                              <div style={{ fontSize: '12px', color: '#999' }}>
                                路径: {oldPath}
                              </div>
                            )}
                          </Space>
                        </List.Item>
                      );
                    }}
                  />
                </div>
              )}

              {processing && (
                <div>
                  {currentFile && (
                    <div style={{ marginBottom: '8px', fontSize: '12px', color: '#666' }}>
                      正在处理: {currentFile}
                    </div>
                  )}
                  <Progress
                    percent={Math.round(progress)}
                    status="active"
                    strokeColor={{ from: 'var(--app-primary-color)', to: '#95de64' }}
                  />
                </div>
              )}

              <Space>
                <Button
                  type="default"
                  icon={<EyeOutlined />}
                  onClick={previewRename}
                  disabled={!renameFolderPath.trim() && droppedFilesRef.current.length === 0 && renamePreview.length === 0}
                  size="large"
                >
                  预览重命名
                </Button>
                <Button
                  type="primary"
                  icon={<EditOutlined />}
                  onClick={executeRename}
                  loading={processing}
                  disabled={!renamePreview || (renamePreview && renamePreview.length === 0)}
                  size="large"
                >
                  替换原文件
                </Button>
                {renamePreview && renamePreview.length > 0 && (
                  <Button
                    type="default"
                    icon={<ClearOutlined />}
                    onClick={clearPreview}
                    size="large"
                  >
                    清除预览
                  </Button>
                )}
              </Space>

              {/* 重命名配置 */}
              {renamePreview.length > 0 && (
                <Card size="small" title="重命名设置" type="inner" style={{ marginTop: '16px' }}>
                  <Space direction="vertical" style={{ width: '100%' }}>
                    <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center' }}>
                      <span>移除中文字符</span>
                      <Switch
                        checked={renameOptions.removeChinese}
                        onChange={(checked) => setRenameOptions(prev => ({...prev, removeChinese: checked}))}
                      />
                    </div>
                    <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center' }}>
                      <span>替换空格</span>
                      <Switch
                        checked={renameOptions.replaceSpaces}
                        onChange={(checked) => setRenameOptions(prev => ({...prev, replaceSpaces: checked}))}
                      />
                    </div>
                    <div>
                      <strong>替换字符：</strong>
                      <Input
                        placeholder="替换空格的字符"
                        value={renameOptions.replaceWith}
                        onChange={(e) => setRenameOptions(prev => ({...prev, replaceWith: e.target.value}))}
                        style={{ marginTop: '8px' }}
                      />
                    </div>
                    {/* 仅在非拖放模式且有路径时显示子文件夹选项 */}
                    {renameFolderPath.trim() && !isDragDropMode && (
                      <div style={{ 
                        borderTop: '1px solid #f0f0f0', 
                        paddingTop: '12px',
                        marginTop: '8px'
                      }}>
                        <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center' }}>
                          <span>包含子文件夹</span>
                          <Switch
                            checked={includeSubfolders}
                            onChange={setIncludeSubfolders}
                          />
                        </div>
                        <div style={{ marginTop: '4px', fontSize: '12px', color: '#999' }}>
                          开启后将递归处理文件夹中的所有文件
                        </div>
                      </div>
                    )}
                  </Space>
                </Card>
              )}
            </Space>
          </Card>
        </Col>
      </Row>

      {/* 使用说明 */}
      <Row style={{ marginTop: '24px' }}>
        <Col span={24}>
          <Card title="使用说明" type="inner">
            <Space style={{ width: '100%' }} vertical>
              <div>
                <strong>批量文件重命名：</strong>
                <ul>
                  <li>支持拖拽文件到上方区域进行批量处理</li>
                  <li>也可以输入文件夹路径处理整个文件夹</li>
                  <li>自动移除文件名中的中文字符</li>
                  <li>将空格替换为下划线或其他指定字符</li>
                  <li>支持预览重命名结果后再执行操作</li>
                  <li>可自定义替换字符和重命名规则</li>
                  <li>处理完成后会替换原文件</li>
                  <li>支持包含子文件夹的递归处理（仅文件夹模式）</li>
                </ul>
              </div>
            </Space>
          </Card>
        </Col>
      </Row>
    </div>
  );
};

export default FileRenamePage;